	\subsection{Skybox}
	Nous avons voulu rendre les fenêtres d'openGL plus agréable, le fond noir, par défaut, ne faisant pas très "fini" nous avons créé une Skybox. Qu'est 
	ce qu'une Skybox ?
		\subsubsubsection{Définition d'une Skybox}
		Une skybox est un gros cube constitué de 6 textures sur lesquelles sont projetés un ciel, des montagnes, des bâtiments éloignés, etc ... recréant ainsi 
		l'illusion d'un environnement éloigné en 3D. Toute l'astuce est dans le fait que la caméra observatrice doit être situé au centre de ce gros cube. 
		Comment fonctionne t-elle ?
		\subsubsubsection{Fonctionnement de la Skybox}
		La partie visible de la scène doit être dessinée à l'intérieur de la skybox, pour cela on désactive le test de profondeur et donc on a l'impression que tous 
		les objets sont dessiner à l'intérieur et que le fond est infini. Cette box aura une largeur, longueur et hauteur identique et toutes les faces du cube seront 
		dirigées vers l'intérieur. La box aura donc une position fixe quel que soit la position de la camera, l'orientation sera, évidement, indépendante de la direction 
		de la caméra. Afin de permettre l'illusion nous avons besoin de faire bouger la box de la même façon que la caméra. Comment l'avons nous programmé ?
		\subsubsubsection{Programmation de la Skybox}
		Maintenant que nous avons donné une forme à notre Skybox, il faut maintenant lui donner des couleurs. Pour cela, nous allons utiliser des textures. Celles-ci ne 
		seront ni à une dimension, ni à deux ... ni même à trois ... mais sera une texture cube appelée : "CubeMap", on peut la placer à mi-chemin entre une texture 2D et 
		une texture 3D. Elle peut se représenter, comme son nom l'indique, par un cube composé de 6 faces. Chacune des faces correspond à une direction par rapport au 
		centre du cube soit les faces X Positif (devant), X Négatif (derriére), Y Positif (haut), Y Négatif (bas), Z Positif (gauche) et enfin Z Négatif (droite). Ainsi, 
		chacune d'elle sera une texture 2D. Donc une texture CubeMap correspond à six textures 2D mais contient moins d'information qu'une texture 3D. 	
	\subsection{Camera}  

	\subsection{Lumières et matériaux}  	
	Afin de rendre nos objets beaucoup plus réel nous avons fait une classe Light qui gère les lumières, l'éclairage de la scène, et une classe Material qui sert à 
	définir la manière dont l'objet réagi avec la lumière. Cela donne une vraie consistance aux objets, on peut ainsi donner beaucoup d'effet sur les objets (ombres, 
	reflets, etc.)
		\subsubsubsection{Lumières}
		Nous gérons les effets de lumière en utilisant une classe Light, cette classe contient quatres tableaux de valeur, en GLfloat, pour contenir la valeur de la 
		lumière ambiente (concerne les objets et les lampes, c'est la lumière qui a tellement été dispersée et renvoyée par l'environnement qu'il est impossible de 
		déterminer la direction d'où elle émane. Elle semble venir de toutes les directions. Quand une lumiére ambiante rencontre une surface, elle est renvoyée dans 
		toutes les directions), la lumière diffuse (concerne les objets et les lampes, c'est la lumière qui vient d'une direction particulière, et qui va étre plus 
		brillante si elle arrive perpendiculairement à la surface que si elle est rasante. Par contre, après avoir rencontré la surface, elle est renvoyée uniformément 
		dans toutes les directions), la lumière spéculaire (concerne les objets et les lampes, la lumiére spéculaire vient d'une direction particuliére et est renvoyée 
		par la surface dans une direction particulière. Par exemple un rayon laser réfléchi par un miroir) et enfin la position de la lumière.\\
		Ces valeurs seront utilisées dans les fonctions d'openGL pour gérer la lumiere. Nous pouvons instancier jusqu'à huit lumières et déplacer, changer les valeurs de 
		la lumière. Evidemment la lumière n'agit sur la scène que si les objets on des normales, celles-ci sont calculer dans les chargeurs d'objets. Notre classe hérite 
		de "IDrawable.h" car nous surdéfinissons une fonction draw() dans la lumière qui dessine une sphère jaune autour de la lumiere afin de la visualiser facilement, 
		nous avons fait une fonction "on" et "off" qui active et désactive la lumiere\\
		Voici une partie du code :
		\begin{lstlisting} 
class SHARED Light : public IDrawable
{
	private :

GLfloat Light_Ambient[4];
GLfloat Light_Diffuse[4];
GLfloat Light_Specular[4];
GLfloat Light_Position[4];

GLenum NumLight;

	public :

Light(GLenum NumLight = GL_LIGHT0);

void on() const
{
	glEnable(GL_LIGHTING);    
	glEnable(NumLight);

	glLightfv( NumLight, GL_AMBIENT, Light_Ambient );
	glLightfv( NumLight, GL_DIFFUSE, Light_Diffuse );
	glLightfv( NumLight, GL_SPECULAR, Light_Specular );
	glLightfv( NumLight, GL_POSITION, Light_Position );
}
void off() const
{  
	glDisable(GL_LIGHTING); 
	glDisable(NumLight);
} 

void setAmbient(const Color4f &color);
void setDiffuse(const Color4f &color);
void setSpecular(const Color4f &color);
void setPosition(const Vector3f &position, int infinit = 1.0);

virtual void draw() const;
}
		\end{lstlisting}		
		\subsubsubsection{Matériaux}
		Nous avons gérer les effets de matière sur les objets, pour cela nous avons créer un objet matière qui possède trois tableaux de GLfloat, un tableau
		de matière ambiante, de matière diffuse et de matière spéculaire. Ces tableaux s'occuperont de gérer ce que reflète l'objet, ainsi on peut en mettant 
		des valeurs précises, donner un rendu métal, plastique, etc. à l'objet. Chaque objet possède sa propre matière, cette matière est déclarer dans le mesh
		de l'objet.
		\begin{lstlisting}
class SHARED Material
{
  private:

    GLfloat Material_Ambient[4];
    GLfloat Material_Diffuse[4];
    GLfloat Material_Specular[4];
    //Shininess of the object
    float _shininess;

  public :
  
    Material();
    
    void activate() const;

    void setAmbient(const Color4f &color);
    void setDiffuse(const Color4f &color);
    void setSpecular(const Color4f &color);
    void setShininess(float shininess);
  
	//return the value of all material composants
    void getAllMat() const;
}
		\end{lstlisting}		
		
